////////////////////////////////////////////////////////////////////////////////
// The Loki Library
// Copyright (c) 2001 by Andrei Alexandrescu
// Copyright (c) 2005 by Peter Kuemmel
// This code DOES NOT accompany the book:
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
//     Patterns Applied". Copyright (c) 2001. Addison-Wesley.
//
// Code covered by the MIT License
// The authors make no representations about the suitability of this software
// for any purpose. It is provided "as is" without express or implied warranty.
////////////////////////////////////////////////////////////////////////////////
#ifndef LOKI_FACTORYPARM_INC_
#define LOKI_FACTORYPARM_INC_

// $Id: Factory.h 788 2006-11-24 22:30:54Z clitte_bbt $


#include "LokiTypeInfo.h"
#include "Functor.h"
#include "AssocVector.h"
#include "SmallObj.h"
#include "Sequence.h"

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4702)
//unreachable code if OnUnknownType throws an exception
#endif

/**
 * \defgroup	FactoriesGroup Factories
 * \defgroup	FactoryGroup Factory
 * \ingroup		FactoriesGroup
 * \brief		Implements a generic object factory.
 *
 * <i>The Factory Method pattern is an object-oriented design pattern.
 * Like other creational patterns, it deals with the problem of creating objects
 * (products) without specifying the exact class of object that will be created.
 * Factory Method, one of the patterns from the Design Patterns book, handles
 * this problem by defining a separate method for creating the objects, which
 * subclasses can then override to specify the derived type of product that will
 * be created.
 * <br>
 * More generally, the term Factory Method is often used to refer to any method
 * whose main purpose is creation of objects.</i>
 * <div ALIGN="RIGHT"><a href="http://en.wikipedia.org/wiki/Factory_method_pattern">
 * Wikipedia</a></div>
 *
 * Loki proposes a generic version of the Factory. Here is a typical use.<br>
 * <code><br>
 * 1. Factory< AbstractProduct, int > aFactory;<br>
 * 2. aFactory.Register( 1, createProductNull );<br>
 * 3. aFactory.CreateObject( 1 ); <br>
 * </code><br>
 * <br>
 * - 1. The declaration<br>
 * You want a Factory that produces AbstractProduct.<br>
 * The client will refer to a creation method through an int.<br>
 * - 2.The registration<br>
 * The code that will contribute to the Factory will now need to declare its
 * ProductCreator by registering them into the Factory.<br>
 * A ProductCreator is a just a function that will return the right object. ie <br>
 * <code>
 * Product* createProductNull()<br>
 * {<br>
 *     return new Product<br>
 * }<br>
 * </code><br>
 * - 3. The use<br>
 * Now the client can create object by calling the Factory's CreateObject method
 * with the right identifier. If the ProductCreator were to have arguments
 * (<i>ie :Product* createProductParm( int a, int b )</i>)
 */

namespace Loki
{

/**
 * \defgroup	FactoryErrorPoliciesGroup Factory Error Policies
 * \ingroup		FactoryGroup
 * \brief		Manages the "Unknown Type" error in an object factory
 *
 * \class DefaultFactoryError
 * \ingroup		FactoryErrorPoliciesGroup
 * \brief		Default policy that throws an exception
 *
 */

template <typename IdentifierType, class AbstractProduct>
struct DefaultFactoryError
{
	struct Exception : public std::exception
	{
		const char *what() const throw()
		{
			return "Unknown Type";
		}
	};

	static AbstractProduct *OnUnknownType(IdentifierType)
	{
		throw Exception();
	}
};


#define LOKI_ENABLE_NEW_FACTORY_CODE
#ifdef LOKI_ENABLE_NEW_FACTORY_CODE


////////////////////////////////////////////////////////////////////////////////
// class template FunctorImpl
////////////////////////////////////////////////////////////////////////////////

struct FactoryImplBase
{
	typedef EmptyType Parm1;
	typedef EmptyType Parm2;
	typedef EmptyType Parm3;
	typedef EmptyType Parm4;
	typedef EmptyType Parm5;
	typedef EmptyType Parm6;
	typedef EmptyType Parm7;
	typedef EmptyType Parm8;
	typedef EmptyType Parm9;
	typedef EmptyType Parm10;
	typedef EmptyType Parm11;
	typedef EmptyType Parm12;
	typedef EmptyType Parm13;
	typedef EmptyType Parm14;
	typedef EmptyType Parm15;
};

template <typename AP, typename Id, typename TList >
struct FactoryImpl;

template<typename AP, typename Id>
struct FactoryImpl<AP, Id, NullType>
		: public FactoryImplBase
{
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id ) = 0;
};
template <typename AP, typename Id, typename P1 >
struct FactoryImpl<AP,Id, Seq<P1> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2 >
struct FactoryImpl<AP, Id, Seq<P1, P2> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2,typename P3 >
struct FactoryImpl<AP, Id, Seq<P1, P2, P3> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2,typename P3,typename P4 >
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4 ) = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5 >
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6 )
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7 )
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	typedef typename TypeTraits<P8>::ParameterType Parm8;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7, Parm8)
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	typedef typename TypeTraits<P8>::ParameterType Parm8;
	typedef typename TypeTraits<P9>::ParameterType Parm9;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7, Parm8, Parm9)
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	typedef typename TypeTraits<P8>::ParameterType Parm8;
	typedef typename TypeTraits<P9>::ParameterType Parm9;
	typedef typename TypeTraits<P10>::ParameterType Parm10;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7, Parm8, Parm9,Parm10)
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	typedef typename TypeTraits<P8>::ParameterType Parm8;
	typedef typename TypeTraits<P9>::ParameterType Parm9;
	typedef typename TypeTraits<P10>::ParameterType Parm10;
	typedef typename TypeTraits<P11>::ParameterType Parm11;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7, Parm8, Parm9,Parm10,
	                         Parm11)
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	typedef typename TypeTraits<P8>::ParameterType Parm8;
	typedef typename TypeTraits<P9>::ParameterType Parm9;
	typedef typename TypeTraits<P10>::ParameterType Parm10;
	typedef typename TypeTraits<P11>::ParameterType Parm11;
	typedef typename TypeTraits<P12>::ParameterType Parm12;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7, Parm8, Parm9,Parm10,
	                         Parm11,Parm12)
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	typedef typename TypeTraits<P8>::ParameterType Parm8;
	typedef typename TypeTraits<P9>::ParameterType Parm9;
	typedef typename TypeTraits<P10>::ParameterType Parm10;
	typedef typename TypeTraits<P11>::ParameterType Parm11;
	typedef typename TypeTraits<P12>::ParameterType Parm12;
	typedef typename TypeTraits<P13>::ParameterType Parm13;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7, Parm8, Parm9,Parm10,
	                         Parm11,Parm12,Parm13)
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13,typename P14>
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	typedef typename TypeTraits<P8>::ParameterType Parm8;
	typedef typename TypeTraits<P9>::ParameterType Parm9;
	typedef typename TypeTraits<P10>::ParameterType Parm10;
	typedef typename TypeTraits<P11>::ParameterType Parm11;
	typedef typename TypeTraits<P12>::ParameterType Parm12;
	typedef typename TypeTraits<P13>::ParameterType Parm13;
	typedef typename TypeTraits<P14>::ParameterType Parm14;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7, Parm8, Parm8,Parm10,
	                         Parm11,Parm12,Parm13,Parm14)
	= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13,typename P14,typename P15 >
struct FactoryImpl<AP, Id, Seq<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >
		: public FactoryImplBase
{
	typedef typename TypeTraits<P1>::ParameterType Parm1;
	typedef typename TypeTraits<P2>::ParameterType Parm2;
	typedef typename TypeTraits<P3>::ParameterType Parm3;
	typedef typename TypeTraits<P4>::ParameterType Parm4;
	typedef typename TypeTraits<P5>::ParameterType Parm5;
	typedef typename TypeTraits<P6>::ParameterType Parm6;
	typedef typename TypeTraits<P7>::ParameterType Parm7;
	typedef typename TypeTraits<P8>::ParameterType Parm8;
	typedef typename TypeTraits<P9>::ParameterType Parm9;
	typedef typename TypeTraits<P10>::ParameterType Parm10;
	typedef typename TypeTraits<P11>::ParameterType Parm11;
	typedef typename TypeTraits<P12>::ParameterType Parm12;
	typedef typename TypeTraits<P13>::ParameterType Parm13;
	typedef typename TypeTraits<P14>::ParameterType Parm14;
	typedef typename TypeTraits<P15>::ParameterType Parm15;
	virtual ~FactoryImpl() {}
	virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
	                         Parm6, Parm7, Parm8, Parm9,Parm10,
	                         Parm11,Parm12,Parm13,Parm14,Parm15 )
	= 0;
};

#ifndef LOKI_DISABLE_TYPELIST_MACROS

template <typename AP, typename Id, typename P1 >
struct FactoryImpl<AP,Id, LOKI_TYPELIST_1( P1 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_2( P1, P2 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2,typename P3 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_3( P1, P2, P3 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3 ) = 0;
};

template<typename AP, typename Id, typename P1,typename P2,typename P3,typename P4 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_4( P1, P2, P3, P4 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4 ) = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_5( P1, P2, P3, P4, P5 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5 ) = 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_6( P1, P2, P3, P4, P5, P6 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6 )
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_7( P1, P2, P3, P4, P5, P6, P7 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7 )
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_8( P1, P2, P3, P4, P5, P6, P7, P8 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_9( P1, P2, P3, P4, P5, P6, P7, P8, P9 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_10( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_11( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10,
                         Parm11)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_12( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10,
                         Parm11,Parm12)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_13( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10,
                         Parm11,Parm12,Parm13)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13,typename P14>
struct FactoryImpl<AP, Id, LOKI_TYPELIST_14( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
    typedef typename TypeTraits<P14>::ParameterType Parm14;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm8,Parm10,
                         Parm11,Parm12,Parm13,Parm14)
= 0;
};

template<typename AP, typename Id,
         typename P1,typename P2,typename P3,typename P4,typename P5,
         typename P6,typename P7,typename P8,typename P9,typename P10,
         typename P11,typename P12,typename P13,typename P14,typename P15 >
struct FactoryImpl<AP, Id, LOKI_TYPELIST_15( P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 )>
: public FactoryImplBase
{
    typedef typename TypeTraits<P1>::ParameterType Parm1;
    typedef typename TypeTraits<P2>::ParameterType Parm2;
    typedef typename TypeTraits<P3>::ParameterType Parm3;
    typedef typename TypeTraits<P4>::ParameterType Parm4;
    typedef typename TypeTraits<P5>::ParameterType Parm5;
    typedef typename TypeTraits<P6>::ParameterType Parm6;
    typedef typename TypeTraits<P7>::ParameterType Parm7;
    typedef typename TypeTraits<P8>::ParameterType Parm8;
    typedef typename TypeTraits<P9>::ParameterType Parm9;
    typedef typename TypeTraits<P10>::ParameterType Parm10;
    typedef typename TypeTraits<P11>::ParameterType Parm11;
    typedef typename TypeTraits<P12>::ParameterType Parm12;
    typedef typename TypeTraits<P13>::ParameterType Parm13;
    typedef typename TypeTraits<P14>::ParameterType Parm14;
    typedef typename TypeTraits<P15>::ParameterType Parm15;
virtual ~FactoryImpl() {}
virtual AP *CreateObject(const Id &id,Parm1, Parm2, Parm3, Parm4, Parm5,
                         Parm6, Parm7, Parm8, Parm9,Parm10,
                         Parm11,Parm12,Parm13,Parm14,Parm15 )
= 0;
};

#endif //LOKI_DISABLE_TYPELIST_MACROS


////////////////////////////////////////////////////////////////////////////////
///  \class Factory
///
///  \ingroup FactoryGroup
///  Implements a generic object factory.
///
///  Create functions can have up to 15 parameters.
///
///  \par Singleton lifetime when used with Loki::SingletonHolder
///  Because Factory uses internally Functors which inherits from
///  SmallObject you must use the singleton lifetime
///  \code Loki::LongevityLifetime::DieAsSmallObjectChild \endcode
///  Alternatively you could suppress for Functor the inheritance
///  from SmallObject by defining the macro:
/// \code LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT \endcode
////////////////////////////////////////////////////////////////////////////////
template
<
class AbstractProduct,
      typename IdentifierType,
      typename CreatorParmTList = NullType,
      template<typename, class> class FactoryErrorPolicy = DefaultFactoryError
      >
class Factory : public FactoryErrorPolicy<IdentifierType, AbstractProduct>
{
	typedef FactoryImpl< AbstractProduct, IdentifierType, CreatorParmTList > Impl;

	typedef typename Impl::Parm1 Parm1;
	typedef typename Impl::Parm2 Parm2;
	typedef typename Impl::Parm3 Parm3;
	typedef typename Impl::Parm4 Parm4;
	typedef typename Impl::Parm5 Parm5;
	typedef typename Impl::Parm6 Parm6;
	typedef typename Impl::Parm7 Parm7;
	typedef typename Impl::Parm8 Parm8;
	typedef typename Impl::Parm9 Parm9;
	typedef typename Impl::Parm10 Parm10;
	typedef typename Impl::Parm11 Parm11;
	typedef typename Impl::Parm12 Parm12;
	typedef typename Impl::Parm13 Parm13;
	typedef typename Impl::Parm14 Parm14;
	typedef typename Impl::Parm15 Parm15;

	typedef Functor<AbstractProduct *, CreatorParmTList> ProductCreator;

	typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;

	IdToProductMap associations_;

public:

	Factory()
		: associations_()
	{
	}

	~Factory()
	{
		associations_.erase(associations_.begin(), associations_.end());
	}

	bool Register(const IdentifierType &id, ProductCreator creator)
	{
		return associations_.insert(
		           typename IdToProductMap::value_type(id, creator)).second != 0;
	}

	template <class PtrObj, typename CreaFn>
	bool Register(const IdentifierType &id, const PtrObj &p, CreaFn fn)
	{
		ProductCreator creator( p, fn );
		return associations_.insert(
		           typename IdToProductMap::value_type(id, creator)).second != 0;
	}

	bool Unregister(const IdentifierType &id)
	{
		return associations_.erase(id) != 0;
	}

	std::vector<IdentifierType> RegisteredIds()
	{
		std::vector<IdentifierType> ids;
		for(typename IdToProductMap::iterator it = associations_.begin();
		        it != associations_.end(); ++it)
		{
			ids.push_back(it->first);
		}
		return ids;
	}

	AbstractProduct *CreateObject(const IdentifierType &id)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2, Parm3 p3)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
	                              Parm6 p6)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
	                              Parm6 p6, Parm7 p7 )
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
	                              Parm6 p6, Parm7 p7, Parm8 p8)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
	                              Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9 );
		return this->OnUnknownType(id);
	}
	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
	                              Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9,Parm10 p10)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1  p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5  p5,
	                              Parm6  p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10,
	                              Parm11 p11)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1  p1,  Parm2  p2, Parm3 p3, Parm4 p4, Parm5  p5,
	                              Parm6  p6,  Parm7  p7, Parm8 p8, Parm9 p9, Parm10 p10,
	                              Parm11 p11, Parm12 p12)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1  p1,  Parm2  p2,  Parm3  p3, Parm4 p4, Parm5  p5,
	                              Parm6  p6,  Parm7  p7,  Parm8  p8, Parm9 p9, Parm10 p10,
	                              Parm11 p11, Parm12 p12, Parm13 p13)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4, Parm5  p5,
	                              Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9, Parm10 p10,
	                              Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14 );
		return this->OnUnknownType(id);
	}

	AbstractProduct *CreateObject(const IdentifierType &id,
	                              Parm1  p1,  Parm2  p2,  Parm3  p3,  Parm4  p4,  Parm5  p5,
	                              Parm6  p6,  Parm7  p7,  Parm8  p8,  Parm9  p9,  Parm10 p10,
	                              Parm11 p11, Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
			return (i->second)( p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15 );
		return this->OnUnknownType(id);
	}

};

#else

template
<
class AbstractProduct,
      typename IdentifierType,
      typename ProductCreator = AbstractProduct *( *)(),
      template<typename, class>
      class FactoryErrorPolicy = DefaultFactoryError
      >
class Factory
	: public FactoryErrorPolicy<IdentifierType, AbstractProduct>
{
public:
	bool Register(const IdentifierType &id, ProductCreator creator)
	{
		return associations_.insert(
		           typename IdToProductMap::value_type(id, creator)).second != 0;
	}

	bool Unregister(const IdentifierType &id)
	{
		return associations_.erase(id) != 0;
	}

	AbstractProduct *CreateObject(const IdentifierType &id)
	{
		typename IdToProductMap::iterator i = associations_.find(id);
		if (i != associations_.end())
		{
			return (i->second)();
		}
		return this->OnUnknownType(id);
	}

private:
	typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
	IdToProductMap associations_;
};

#endif //#define ENABLE_NEW_FACTORY_CODE

/**
 *   \defgroup	CloneFactoryGroup Clone Factory
 *   \ingroup	FactoriesGroup
 *   \brief		Creates a copy from a polymorphic object.
 *
 *   \class		CloneFactory
 *   \ingroup	CloneFactoryGroup
 *   \brief		Creates a copy from a polymorphic object.
 */

template
<
class AbstractProduct,
      class ProductCreator =
      AbstractProduct *( *)(const AbstractProduct *),
      template<typename, class>
      class FactoryErrorPolicy = DefaultFactoryError
      >
class CloneFactory
	: public FactoryErrorPolicy<TypeInfo, AbstractProduct>
{
public:
	bool Register(const TypeInfo &ti, ProductCreator creator)
	{
		return associations_.insert(
		           typename IdToProductMap::value_type(ti, creator)).second != 0;
	}

	bool Unregister(const TypeInfo &id)
	{
		return associations_.erase(id) != 0;
	}

	AbstractProduct *CreateObject(const AbstractProduct *model)
	{
		if (model == NULL)
		{
			return NULL;
		}

		typename IdToProductMap::iterator i =
		    associations_.find(typeid(*model));

		if (i != associations_.end())
		{
			return (i->second)(model);
		}
		return this->OnUnknownType(typeid(*model));
	}

private:
	typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap;
	IdToProductMap associations_;
};

} // namespace Loki


#ifdef _MSC_VER
#pragma warning( pop )
#endif

#endif // end file guardian

